// 借用构造函数
function Person(name, age, sex) {
  this.name = name
  this.age = age
  this.sex = sex
}

function Student(name, age, sex, grade) {
  Person.call(this, name, age, sex)
  this.grade = grade
}
var student = new Student()
console.log(student)

Father.prototype.name = 'zs'
function Father() {}
function Son() {}
Son.prototype = Father.prototype
var son = new Son()
console.log(son.name) // zs
son.name = 'ls'
Son.prototype.sex = 'male'
console.log(Father.prototype.name)
console.log(son.name) // zs
console.log(Father.prototype.sex)

// 抽象出来一个功能，封装成为一个函数
// CSS属性，文字类的属性有一个传递的特性，子元素没设置就设置成为父元素的属性
// 构造函数构造出来的所有对象都改一下this的指向

function inherit(Target, Origin) {
  Target.prototype = Origin.prototype
}

// 圣杯模式！
function inherit(Son, Father) {
  function F() {}
  // 用new F() 实现原型或者this的改变是常见的做法！
  F.prototype = Father.prototype
  Son.prototype = new F()
  // 带来的问题就是没有constructor, 构造原型指向自己！ 独立！
  // 改之前的constructor是Father，对象没有constructor，往上找 F().__proto__ => Father.prototype 有
  // constructor，指向的是Father！
  Son.prototype.constructor = Son
  // 添加一个属性记录一下继承自谁，方便后续的查找！不能用super保留字 => uber
  Son.prototype.uber = Father.prototype
}

var inherit = (function () {
  var F = function () {}
  return function (Son, Father) {
    F.prototype = Father.prototype
    Son.prototype = new F()
    Son.prototype.constructor = Son
    Son.prototype.uber = Father.prototypes
  }
})()
// return 一个函数和 return一个函数引用是相同的，一样！
// 这里的F是一个函数变量，利用闭包私有化这个函数的变量，外界无法访问，秒！F形成闭包
// F没有别的实际用途，无关的东西私有化，高端写法！
var inherit = (function () {
  var F = function () {}
  function demo(Son, Father) {
    F.prototype = Father.prototype
    Son.prototype = new F()
    Son.prototype.constructor = Son
    Son.prototype.uber = Father.prototypes
  }
  return demo
})()
